Method and apparatus for integer division

ABSTRACT

A method, arithmetic divider unit, and system are disclosed for dividing a dividend DZM . . . Z0 having a most significant bit ZM and a plurality of less significant bits ZM−1 through Z0 by a divisor RZN . . . Z0 having a most significant bit ZN and a plurality of less significant bits ZN−1 through Z0. The method, arithmetic divisor unit, and system round the divisor to the next significant bit greater than the divisor&#39;s most significant bit ZN to produce a first partial divisor RZN+1, divide the dividend DZM . . . Z0 by the first partial divisor RZN+1 to produce a first partial quotient QN, calculate one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits ZN−1 through Z0, and add the first partial quotient QN and one or more additional partial quotients to produce an estimated final quotient.

FIELD OF THE INVENTION

The present invention relates generally to a processor including an arithmetic logic unit and preferably including a divider unit performing integer division within such processor.

BACKGROUND OF THE INVENTION

Digital devices perform a variety of arithmetic operations on binary numerical data. A processor within such digital devices includes a major subdivision called an arithmetic logic unit (ALU). The ALU performs a variety of data processing and arithmetic operations under the control of the processor. Although early processors had only one ALU, modern chips may have several ALUs, which may be classed into two types. One basic type of ALU is an integer unit which carries out simple integer mathematical operations including add, subtract, multiply, shift and logical instructions. More powerful processors also may include a second type of ALU, referred to as a floating-point unit, that handles advanced math operations on numbers with a wider range than simple integers (such as 1.03.times.10.sup.−19 for example.) Floating-point units use separate, dedicated instructions for their advanced functions.

The basic integer unit may also include a dedicated divider to perform arithmetic division. Because floating-point numbers and integers are represented differently in binary, and because the operations differ as a result, separate floating point and integer dividers are generally provided. Typically, floating point division is considered to be more important for high-demand applications, such as graphics and multimedia applications. Also, integer division is not performed with the same frequency as other mathematical operations. And so, many manufacturers save die real estate by providing only the most basic single bit per cycle (radix-2) integer divider, which reduces performance.

The integer divider commonly operates based on one of a variety of well-known subtractive algorithms. Subtractive algorithms each include a sequence of shift, subtract, and compare operations. Among subtractive algorithms, restoring, non-restoring, non-performing, and the Sweeney, Robertson, and Tocher (SRT) division algorithms are known. These division algorithms tend to be very slow in generating quotient values.

For example, one conventional subtractive division technique for binary numbers works similarly to standard long division in base-10 numbers. Each digit of the dividend, starting with the most significant digit, is compared to the divisor, and a digit of the quotient is computed. In computers, this is accomplished by the typical one bit per cycle (radix-2) integer divider by aligning the most significant bit of the dividend with the least significant bit of the divisor, subtracting the aligned digits, shifting the partial remainder to the left, subtracting, shifting again, and so on. For a 64-bit number, the minimum number of cycles is 64, plus several cycles for setting up the computation. Even in cases where the numbers have significantly fewer digits or the dividend is smaller than the divisor (a case which always results in zero for integer numbers) the entire process is performed. Thus, even radix-4 and radix-8 integer dividers, which process multiple bits per cycle, can be very inefficient.

An exemplary prior art non-restoring integer divider 20 is schematically represented in FIG. 1. The 64-bit dividend is right shifted by 63 bits using concatenation 22. The concatenated 128 bit word is stored in flip-flop 26. The left 65 bits, including one sign bit and the 64 bit partial remainder are read out and added in adder 34. The divisor is stored in flip-flop 28, converted into its two's compliment form using XOR 32, and added in carry-lookahead adder 34. The result from adder 34 is the partial remainder from which quotient digit 38 q(i) is calculated. Concatenation 36 combines the right 63 bits from split 29 with result from adder 34 and q(i). The cycle repeats 64 times and the final result is stored in the least significant 64 bits of flip-flop 26.

It would be desirable to improve the performance of integer division and to reduce real estate requirements on the integrated circuit die while at the same time improving division performance on integer numbers.

SUMMARY OF THE INVENTION

Broadly speaking, the present invention fills these needs by providing a fast and efficient method and device for dividing an integer dividend by an integer divisor.

It should be appreciated that the present invention can be implemented in numerous ways, including as a process, an apparatus, a system, a device, or a method. Several inventive embodiments of the present invention are described below.

In one embodiment, the invention provides a method for dividing a dividend D_(ZM . . . Z0) having a most significant bit Z_(M) and a plurality of less significant bits Z_(M−1) through Z₀ by a divisor R_(ZN . . . Z0) having a most significant bit Z_(N) and a plurality of less significant bits Z_(N−1) through Z₀. The method includes: rounding the divisor to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a first partial divisor R_(ZN+1); dividing the dividend D_(ZM . . . Z0) by the first partial divisor R_(ZN+1) to produce a first partial quotient Q_(N); calculating one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits Z_(N−1) through Z₀; and adding the first partial quotient Q_(N) and one or more additional partial quotients to produce an estimated final quotient.

In another embodiment, the invention provides an arithmetic divider unit for dividing a dividend D_(ZM . . . Z0) having a most significant bit Z_(M) and a plurality of less significant bits Z_(M−1) through Z₀ by a divisor R_(ZN . . . Z0) having a most significant bit Z_(N) and a plurality of less significant bits Z_(N−1) through Z₀. The arithmetic divider unit includes: arithmetic logic capable of rounding the divisor to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a first partial divisor R_(ZN+1); shift logic capable of dividing the dividend D_(ZM . . . Z0) by the first partial divisor R_(ZN+1) to produce a first partial quotient Q_(N); processing logic capable of calculating one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits Z_(N−1) through Z₀; and adder logic adding the first partial quotient Q_(N) and one or more additional partial quotients to produce an estimated final quotient.

In yet another embodiment, the invention provides a system for dividing a dividend D_(ZM . . . Z0) having a most significant bit Z_(M) and a plurality of less significant bits Z_(M−1) through Z₀ by a divisor R_(ZN . . . Z0) having a most significant bit Z_(N) and a plurality of less significant bits Z_(N−1) through Z₀. The system includes a processor configured to execute the following steps: rounding the divisor to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a first partial divisor R_(ZN+1); dividing the dividend D_(ZM . . . Z0) by the first partial divisor R_(ZN+1) to produce a first partial quotient Q_(N); calculating one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits Z_(N−1) through Z₀; and adding the first partial quotient Q_(N) and one or more additional partial quotients to produce an estimated final quotient.

The advantages of the present invention will become apparent from the following detailed description, taken in conjunction with the accompanying drawings, illustrating by way of example the principles of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention will be readily understood by the following detailed description in conjunction with the accompanying drawings, and like reference numerals designate like structural elements.

FIG. 1 shows an implementation schematic for an exemplary prior art non-restoring integer divider.

FIG. 2 shows a flowchart describing an exemplary method for efficiently carrying out integer division.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The integer division algorithm of the present invention may be implemented as a sequence of steps within a processor lacking a dedicated divider but having a basic ALU including add, subtract, multiply, shift, and logical instructions. In an alternative embodiment, the integer divider may be implemented in hardware as a separate divider unit using conventional combinational logic blocks in accordance with known techniques.

FIG. 2 shows a flowchart describing an exemplary method for efficiently carrying out integer division, given a dividend D having bits Z_(M) . . . Z₀ and a divisor R having bits Z_(N) . . . Z₀. Bit Z_(M) is the most significant bit (MSB) of the dividend D, and bit Z_(N) is the MSB of divisor R. Further, M is assumed to be greater than N.

Dividend D and divisor R may include leading zeros before the MSB bits Z_(M) and Z_(N). Such leading zeros may be eliminated by scanning dividend D and divisor R from the left to identify the first bit position that has a value of ‘1’ and then dropping any leading zeros.

The procedure starts in detail at block 200 as shown. In step 205, the divisor R_(ZN . . . Z0) is rounded to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a partial divisor R_(ZN+1). For binary division, this step may be performed by taking the highest bit position (MSB) in the divisor R and multiplying it by 2 (e.g., via a multiply subunit or a shift register unit). Next, in step 210, the dividend D_(ZM . . . Z0) is divided by the partial divisor R_(ZN+1) to produce a first partial quotient Q_(N). This division can be accomplished, for example, by performing a right shift operation, e.g., via a shift register.

In steps 215 through 230, additional partial quotients are calculated iteratively for each remaining divisor bit Z_(N−1) through Z₀ having a binary value of “0.” For the sake of illustration and not by way of limitation, in the method depicted in FIG. 2, a counter Y is used to step through each remaining divisor bit Z_(N−1) through Z₀ of the divisor R.

In step 215, counter Y is incremented (from an initial starting value of zero), and a comparison is made between the counter Y and the number of bits N of divisor R.

In block 220, assuming that the value of counter Y is equal to or less than the number of bits N in divisor R, the bit value R_(ZN−Y) is compared to a binary value “0.” If divisor bit value R_(ZN−Y) is equal to zero, then operation continues in block 225. In block 225, a partial quotient Q_(N−Y) is calculated, preferably iteratively, by dividing the previously calculated partial quotient Q_(N+1−Y), by a binary 2 (e.g., via a shift register unit), except where the previously calculated partial quotient is zero. In the case where the previously calculated partial quotient is zero (and the value R_(ZN−Y) is equal to zero), the new quotient value is preferably computed by dividing Q_(N) by 2^(Y), which computation can be performed by a shift register) If divisor bit value R_(ZN−Y) is one, however, then in block 230 the partial quotient Q_(N−Y) is set to a value of zero.

Finally, in step 235, the partial quotients Q₀ through Q_(N) calculated in step 225 are added together to produce an estimated final quotient Q_(EST). The estimated final quotient Q_(EST) represents a good approximation of the value that would be obtained using conventional long binary division. Further, the estimated final quotient Q_(EST) may be very quickly obtained, especially when the above method is implemented in hardware via combinational logic.

An example of the method described above with reference to steps 200 through 235 follows, given the following 8-bit dividend D and 4-bit divisor R_(ZN . . . Z0) (where N=3):

$\frac{D_{Z7Z6Z5Z4\_ Z3Z2Z1Z0}}{R_{Z\; 3Z\; 2Z\; 1Z\; 0}} = \frac{1010\_ 1001}{1010}$

In this example, in step 205 of FIG. 2, the divisor R_(ZN . . . Z0)=1010 is rounded to the next significant bit greater than the divisor's most significant bit. Partial divisor R_(ZN+1) would thus be binary 10000 (decimal 16). Next, in step 210, the dividend D=1010_(—)1001 is divided by the partial divisor R_(ZN+1) (i.e., binary 10000) to produce the first partial quotient Q₃=1010. In step 215, counter Y is incremented from 0 to 1 and then compared to N of 3. After incrementing, counter Y equals one, which is not greater than N, and operation thus continues to step 220. In step 220, the bit value of the second most significant bit Z₂ of the divisor R is compared to zero. Because divisor bit R_(Z2)2=0, operation proceeds to step 225, in which the second partial quotient Q₂ is calculated by dividing Q₃ by the value 2, as follows: Q ₂ =Q ₃/2=1010/2=101.

Operation again returns to step 215, and counter Y is incremented from 1 to 2. After incrementing, counter Y equals two, which is not greater than N=3, and operation thus continues to step 220. In step 220, the bit value of the third most significant bit Z₁ of the divisor R is compared to zero. Because divisor bit R_(Z1)=1, operation proceeds to step 230, in which the third partial quotient Q₁ is set to zero.

Finally in this example, operation yet again returns to step 215. Counter Y is incremented from 2 to 3 and then compared to N of 3. After incrementing, counter Y equals three, which is not greater than N=3, and operation thus proceeds again to step 220. In step 220, the bit value of the least significant bit Z₀ of the divisor R is compared to zero. Because divisor bit R_(Z0)=0, operation again proceeds to step 225, in which the fourth partial quotient Q₀ is calculated by dividing Q₂ by the value 4, as follows: Q ₀ =Q ₂/4=101/4=1.

Finally, in step 235 in this example, the estimated final quotient Q_(EST) is obtained by summing all of the partial quotients Q₀ . . . Q₃. Q _(EST) =Q ₃ +Q ₂ +Q ₁ +Q ₃=1010+101+0+1=16

The estimated quotient Q_(EST) obtained in step 235 may include an error component Q_(ERR). The present inventors have determined that the accuracy of the present method for division may be improved by performing an error correction calculation, because the error Q_(ERR) that is introduced by the above method is determinative. Accordingly, in step 240 the error Q_(ERR) is calculated, and in step 245 the corrected final quotient Q_(FINAL) is determined by calculating Q_(EST)+Q_(ERR).

An exemplary formula for determining the error Q_(ERR) is derived as follows.

The first approximation in the present method for division is performed in step 205, when the divisor R_(ZN . . . Z0) is rounded to the next significant bit. In so doing, one assumes that all bits in the divisor R_(ZN . . . Z0) are zero except the most significant bit R_(ZN) (having value ‘1’), when scanned from the left. This most significant bit R_(ZN) is rounded by shifting left by one bit. The resulting rounded value (e.g., R_(ZN+1)=10000) will always be at least one bit-value greater than the maximum possible value of the divisor—i.e., the case where all of the divisor bits have a value of ‘1’ (e.g., R_(ZN . . . Z0)=1111). Further, where the rounded value R_(ZN+1) equals the divisor R_(ZN . . . Z0)+1, no correctable error exists. Thus, an error will arise only where the lesser significant bits (i.e., all of the divisor bits excluding the MSB) do not all equal 1. In that event, the estimated quotient value must be increased by the error Q_(ERR).

In order to derive the amount by which the estimated quotient should be increased, one may consider a 4-bit binary number Z including bits Z₃Z₂Z₁Z₀ (where Z₃ is the MSB). The method for division performed in steps 200 through 235 may then be written in equation form as follows:

$\begin{matrix} {\frac{1}{Z} \approx {\frac{1}{16} + {Z_{2}^{\prime}\frac{1}{32}} + {Z_{1}^{\prime}\frac{1}{64}} + {Z_{0}^{\prime}\frac{1}{128}}}} & (1) \end{matrix}$ where Z′_(x) is the one's complement of Z_(x), and Z₃, as the most significant bit of the divisor, is assumed to equal ‘1’. This equation may be rewritten as

$\frac{1}{Z} \approx \frac{8 + {4Z_{2}^{\prime}} + {2Z_{1}^{\prime}} + Z_{0}^{\prime}}{128}$ and further rewritten as Z(8+4Z′₂+2Z′₁+Z′₀)≈128  (2)

By letting A equal Z₂Z₁Z₀ and substituting 8+A into the equation for Z, equation (1) may now be rewritten as

$\begin{matrix} {\frac{1}{\left( {8 + A} \right)} \approx \frac{\left( {8 + A^{\prime}} \right)}{128}} & (3) \end{matrix}$ where A is Z2Z1Z0 and A′ is one's complement of A (i.e., A′=Z′₂Z′₁Z′₀).

Further, the relationship between the accurate corrected final quotient Q_(FINAL), the estimated final quotient Q_(EST) and the definite error Q_(ERR) in the quotient is given by: Q _(FINAL) =Q _(EST)(1+Q _(ERR))  (4)

By using equations (3) and (4),

$\frac{1}{\left( {8 + A} \right)} \approx {\frac{\left( {8 + A^{\prime}} \right)}{128}*\left( {1 + Q_{ERR}} \right)}$

By introducing the definite error quantity Q_(ERR), the left hand side of this resulting equation may now be defined to be exactly equal, rather than merely approximately equal, to the right hand side of the equation. Simplifying this further, one obtains

(8 + A)(8 + A^(′)) * (1 + Q_(ERR)) = 128 ${1 + Q_{ERR}} = \frac{128}{\left( {120 + {AA}^{\prime}} \right)}$ where A+A′ is always equal to 7. Thus, the error Q_(ERR) may be accurately determined by the equation:

$\begin{matrix} {Q_{ERR} = \frac{\left( {8 - {AA}^{\prime}} \right)}{\left( {120 + {AA}^{\prime}} \right)}} & (5) \end{matrix}$

Because equation (5) itself requires a division operation, it is desirable to simplify this error equation by providing an error estimation (or mapping) algorithm that may be implemented in hardware using a shift operation rather than a division operation.

Toward this end, the above theory for deriving the error quotient may be extended to include the generic case with n-bit divisor (with MSB as ‘1’):

$\begin{matrix} {\frac{1}{Z} \approx {\frac{1}{2^{n}} + {Z_{({n - 2})}^{\prime}\frac{1}{2^{({n + 1})}}} + {Z_{({n - 3})}^{\prime}\frac{1}{2^{({n + 2})}}} + \ldots + {Z_{0}^{\prime}\frac{1}{2^{({n + n - 1})}}}}} & (6) \end{matrix}$

Since the MSB (i.e., the nth bit) is always 1, the bits in divisor Z may be written as Z=1 Z _(n−2) Z _(n−3) Z _(n−4) . . . Z ₀

Letting A=(Z_(n−2) Z_(n−3) Z_(n−4) . . . Z₀), divisor Z may be rewritten as Z=2^(n−1) +A

Equation (6) may then be written as:

$\begin{matrix} {\frac{1}{\left( {2^{({n - 1})} + A} \right)} = {\frac{\left( {2^{({n - 1})} + A^{\prime}} \right)}{\left( 2^{({{2n} - 1})} \right)}*\left( {1 + Q_{ERR}} \right)}} & (7) \\ {2^{({{2n} - 1})} = {\left( {2^{({n - 1})} + A^{\prime}} \right)*\left( {2^{({n - 1})} + A} \right)*\left( {1 + Q_{ERR}} \right)}} & (8) \\ {2^{({{2n} - 1})} = \left\{ {\left( {2^{({{2n} - 2})} + {2^{({n - 1})}*\left( {A^{\prime} + A} \right)} + {AA}^{\prime}} \right\}*\left( {1 + Q_{ERR}} \right)} \right.} & (9) \end{matrix}$

Because A+A′ is always equal to 2^((n−1))−1, is equation (9) may be further rewritten as:

$\begin{matrix} {2^{({{2n} - 1})} = {\left\{ {2^{({{2n} - 2})} + {2^{({n - 1})}*\left( {2^{({n - 1})} - 1} \right)} + {AA}^{\prime}} \right\}*\left( {1 + Q_{ERR}} \right)}} & (10) \\ {2^{({{2n} - 1})} = {\left\{ {2^{({{2n} - 2})} + 2^{({{2n} - 2})} - 2^{({n - 1})} + {AA}^{\prime}} \right\}*\left( {1 + Q_{ERR}} \right)}} & (11) \\ {2^{({{2n} - 1})} = {\left\{ {2^{({{2n} - 1})} - 2^{({n - 1})} + {AA}^{\prime}} \right\}*\left( {1 + Q_{ERR}} \right)}} & (12) \\ {\left( {1 + Q_{ERR}} \right) = \frac{2^{({{2n} - 1})}}{2^{({{2n} - 1})} - 2^{({n - 1})} + {AA}^{\prime}}} & (13) \\ {Q_{ERR} = {{\frac{2^{({{2n} - 1})}}{2^{({{2n} - 1})} - 2^{({n - 1})} + {AA}^{\prime}} - 1} = \frac{2^{({n - 1})} - {AA}^{\prime}}{2^{({{2n} - 1})} - \left( {2^{({n - 1})} - {AA}^{\prime}} \right)}}} & (14) \end{matrix}$

Letting the numerator be ‘P’, then

$\begin{matrix} {{Q_{ERR} = \frac{P}{2^{({{2n} - 1})} - P}},{\left. {where}\Rightarrow P \right. = \left( {2^{({n - 1})} - {AA}^{\prime'}} \right)}} & (15) \\ {Q_{ERR} = {{\frac{P}{2^{({{2n} - 1})}}*\left( \frac{1}{1 - \frac{P}{2^{({{2n} - 1})}}} \right)} = {\frac{P}{2^{({{2n} - 1})}}*\left( {1 - \frac{P}{2^{({{2n} - 1})}}} \right)^{- 1}}}} & (16) \end{matrix}$

By using the well-known series expansion, one may write (1−q)⁻¹ as (1+q+q²+q³+ . . . ), if q is less than 1. In the above expression, (P/(2^(2n−1))) is always less than ‘1’. Accordingly,

$\begin{matrix} {Q_{ERR} = {\frac{P}{2^{({{2n} - 1})}}*\left( {1 + \frac{P}{2^{({{2n} - 1})}} + \left\lbrack \frac{P}{2^{({{2n} - 1})}} \right\rbrack^{2} + \left\lbrack \frac{P}{2^{({{2n} - 1})}} \right\rbrack^{3} + \ldots}\mspace{11mu} \right)}} & (17) \end{matrix}$

This equation (17) may be further rewritten in final form as:

$\begin{matrix} {{{Q_{ERR} = \left( {\frac{P}{2^{({{2n} - 1})}} + \left\lbrack \frac{P}{2^{({{2n} - 1})}} \right\rbrack^{2} + \left\lbrack \frac{P}{2^{({{2n} - 1})}} \right\rbrack^{3} + \ldots}\mspace{11mu} \right)},{where}}{P = \left( {2^{({n - 1})} - {AA}^{\prime}} \right)}} & (18) \end{matrix}$

This resulting equation (18) for error estimation may be implemented in hardware or software using multiplication, subtraction and shift modules, which are relatively fast and which require less space on an integrated circuit than a division module.

It will be recognized that the error estimation equation (18) still introduces a small amount of error, because in practice the number of series expansion terms must be finite and limited. The number of terms may be increased or decreased in accordance with the invention, based on the needs of the application for accuracy and speed and on the hardware and software that is available. In a preferred embodiment, the number of terms for the error correction may be determined based on the difference between the dividend and the divisor. For example, if the dividend is a 32 bit number (with MSB as ‘1’) and the divisor is a 2-bit number (with MSB ‘1’), then about 13 terms are needed to ensure that the error in the quotient is less than a bit value of ‘1’. Alternatively, for a 32-bit dividend and a 4-bit divisor (with MSB ‘1’), then about 7 terms are needed to ensure that the error in the quotient is less than a bit value of ‘1’.

Although the foregoing invention has been described in some detail for purposes of clarity of understanding, it will be apparent that certain changes and modifications may be practiced within the scope of the appended claims. Accordingly, the present embodiments are to be considered as illustrative and not restrictive, and the invention is not to be limited to the details given herein, but may be modified within the scope and equivalents of the appended claims. 

1. A method for dividing a dividend D_(ZM . . . Z0) having a most significant bit and a plurality of less significant bits by a divisor having a most significant bit Z_(N) and a plurality of less significant bits Z_(N−1) through Z₀ comprising the steps of: rounding the divisor to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a first partial divisor R_(ZN+1); dividing the dividend D_(ZM . . . Z0) by the first partial divisor R_(ZN+1) to produce a first partial quotient Q_(N); calculating one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits Z_(N−1) through Z₀; and adding the first partial quotient Q_(N) and one or more additional partial quotients to produce an estimated final quotient; wherein the rounding, dividing, calculating and adding steps are performed by a processor.
 2. The method of claim 1, wherein the step of calculating one or more additional partial quotients is performed iteratively.
 3. The method of claim 1, wherein the step of calculating one or more additional partial quotients is performed for each divisor bit Z_(N−1) through Z₀ having a binary value of “0”.
 4. The method of claim 1, wherein the step of calculating one or more additional partial quotients includes the step of setting each additional partial quotient to a “0” value if a corresponding divisor bit has a value of “1”.
 5. The method of claim 1, further comprising the steps of: calculating an error component Q_(ERR); and adding the error component Q_(ERR) to the estimated final quotient to produce a corrected final quotient.
 6. The method of claim 1 further comprising the step of maintaining a counter that is incremented as the partial quotients are generated.
 7. The method of claim 6 wherein in calculating a given one of the additional partial quotients a divisor bit value Z_(N−Y) is compared to a specified binary value and if equal to the specified binary value the given additional partial quotient is computed as a function of a previously computed partial quotient, where Y denotes a current value of the counter.
 8. The method of claim 7 wherein if the divisor bit value Z_(N−Y) is not equal to the specified binary value the given additional partial quotient is not computed as a function of a previously computed partial quotient.
 9. An arithmetic divider unit for dividing a dividend D_(ZM . . . Z0) having a most significant bit and a plurality of less significant bits by a divisor having a most significant bit Z_(N) and a plurality of less significant bits Z_(N−1) through Z₀, comprising: arithmetic logic capable of rounding the divisor to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a first partial divisor R_(ZN+1); shift logic capable of dividing the dividend D_(ZM . . . Z0) by the first partial divisor R_(ZN+1) to produce a first partial quotient Q_(N); processing a logic capable of calculating one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits Z_(N−1) through Z₀; and adder logic adding the first partial quotient Q_(N) and one or more additional partial quotients to produce an estimated final quotient.
 10. The arithmetic divider unit of claim 9, wherein the processing logic is capable of iteratively calculating the one or more additional partial quotients.
 11. The arithmetic divider unit of claim 9, wherein the processing logic is capable of calculating one or more additional partial quotients for each divisor bit Z_(N−1) through Z₀ having a binary value of “0”.
 12. The arithmetic divider unit of claim 9, wherein the processing logic is capable of setting each additional partial quotient to a “0” value if a corresponding divisor bit has a value of “1”.
 13. The arithmetic divider unit of claim 9, further comprising: processing logic capable of calculating an error component Q_(ERR); and adding logic capable of adding the error component Q_(ERR) to the estimated final quotient to produce a corrected final quotient.
 14. An integrated circuit comprising the arithmetic divider unit of claim
 9. 15. A system for dividing a dividend D_(ZM . . . Z0) having a most significant bit and a plurality of less significant bits by a divisor having a most significant bit Z_(N) and a plurality of less significant bits Z_(N−1) through Z₀ comprising: a processor configured to execute the following steps: rounding the divisor to the next significant bit greater than the divisor's most significant bit Z_(N) to produce a first partial divisor R_(ZN+1); dividing the dividend D_(ZM . . . Z0) by the first partial divisor R_(ZN+1) to produce a first partial quotient Q_(N); calculating one or more additional partial quotients based on one or more divisor bits selected from the plurality of divisor bits Z_(N−1) through Z₀; and adding the first partial quotient Q_(N) and one or more additional partial quotients to produce an estimated final quotient.
 16. The processor of claim 15, wherein the processor is further configured to calculate one or more additional partial quotients is performed iteratively.
 17. The processor of claim 15, wherein the processor is configured to calculate the one or more additional partial quotients for each divisor bit Z_(N−1) through Z₀ having a binary value of “0”.
 18. The processor of claim 15, wherein the processor is configured to set each additional partial quotient to a “0” value if a corresponding divisor bit has a value of “1”.
 19. The processor of claim 15, wherein the processor is configured to calculate an error component Q_(ERR) and to add the error component Q_(ERR) to the estimated final quotient to produce a corrected final quotient.
 20. An integrated circuit comprising the system of claim
 15. 